package com.test1;

import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL;
import javax.microedition.khronos.opengles.GL10;
import com.ResourePath;
import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.opengl.GLSurfaceView;
import android.opengl.GLUtils;
import android.opengl.GLSurfaceView.Renderer;
import android.opengl.GLU;
import android.os.Bundle;
import android.view.Window;
import android.view.WindowManager;

/**
 * 使用硬件接口测试
 * @author Clm
 * @日期 2017/2/12 18:44 -> 
 */
public class GLSurfaceViewTest0 extends Activity{
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
		super.onCreate(savedInstanceState);
		MyGLSurfaceView myGlSurfaceView = new MyGLSurfaceView(this);
		setContentView(myGlSurfaceView);
//		myGlSurfaceView.setLayoutParams(new ViewGroup.LayoutParams(LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT));
		myGlSurfaceView.setRenderer(new GLRender());
	}
	private class MyGLSurfaceView extends GLSurfaceView{
		public MyGLSurfaceView(Context context) {
			super(context);
			// TODO Auto-generated constructor stub
		}
		
	}
	
	
	public class GLRender implements Renderer 
	{ 
//	     int one = 0x10000;
//		int one = 0x10000;
		float i = 3;
		float z = -10;
	     
//	     //三角形三个顶点  
//	     private IntBuffer triggerBuffer = IntBuffer.wrap(new int[]{ 
//	            0,one,0,        //上顶点  
//	            -one,-one,0,    //左下点  
//	            one,-one,0,});  //右下点  
	     private float[] triggerBuffer = new float[]{  
//	    	        0,one,0,  
//	    	        -one,-one,0,  
//	    	        one,-one,0,
	    		 -i, -i, z,
	    		 i, -i, z,
	    		 	0, i, z
//	    		 	-i, -i, 0,
//	    		 	i, -i, 0,
//	    		 	-i, i, 0,
//	    		 	i, i, 0
	    	    };
	     private float[] t2 = new float[]{
	    		 i, -i, z,
	    		 2 * i, -i, z,
	    		 i, i, z
	     };
	     //正方形的4个顶点  
//	     private IntBuffer quaterBuffer = IntBuffer.wrap(new int[]{ 
//	                one,one,0, 
//	                -one,one,0, 
//	                one,-one,0, 
//	                -one,-one,0}); 
//	     private int[] quaterBuffer = new int[]{
//	    		 	one,one,0, 
//	                -one,one,0, 
//	                one,-one,0, 
//	                -one,-one,0
//	     };
//	     private FloatBuffer triggerBuffers;
	     float rotate = 0.0f;
	    @Override 
	    public void onDrawFrame(GL10 gl) 
	    { 
	        // 清除屏幕和深度缓存  
	        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT); 
	        // 重置当前的模型观察矩阵  
	        gl.glLoadIdentity();
	        
	      //纹理
	        gl.glEnable(GL10.GL_TEXTURE_2D);
	        gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
	        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
	        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
	         
	        // 左移 1.5 单位，并移入屏幕 6.0  
//	        gl.glTranslatef(0.0f, 0.0f, -10.0f);//这么做,就即物体最终会被渲染到以0.0f,0.0f,-2.0f为世界中心点基准进行渲染得到的结果 
	         
	        // 允许设置顶点  
	        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); 
	        gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);//允许纹理数组使用
//	        gl.glMatrixMode(GL10.GL_MODELVIEW);//设置当前为模型视图
//	        gl.glRotatef(rotate, 0, 1.0f, 0.0f);
//	        rotate += 0.3f;
//	        int j = (int) (rotate % bt.length);
//	        // 设置三角形  
//	        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, bufferUtil(triggerBuffer));
	        
			gl.glBindTexture(GL10.GL_TEXTURE_2D, k);
	        gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, bufferUtil(textureCoor));
//	        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bt[0], 0);//将bimap作为纹理载入指定的缓存区,指定要使用的纹理并在渲染多边形时映射
//	        //绘制三角形  
//	        gl.glDrawArrays(GL10.GL_LINE_LOOP, 0, 6);
	        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, bufferUtil(triggerBuffer));//设置四边形顶点数据(每3个构建一次,顶点数据类型,从第几个点开始,顶点数组数据)
	        gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3);//指定渲染的是四边形,从0开始,共4个顶点
	        // 取消纹理坐标设置  
//	        gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
//	        // 取消顶点设置  
//	        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY); 
	         
	        // 重置当前的模型观察矩阵  
//	        gl.glLoadIdentity(); 
//	        gl.glTranslatef(0.0f, 0.0f, -10.0f);
	        // 允许设置顶点  
//	        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY); 
//	        gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
	     // 左移 1.5 单位，并移入屏幕 6.0  
//	        gl.glEnable(GL10.GL_TEXTURE_2D);
			//纹理
//	        gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
//	        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_S, GL10.GL_CLAMP_TO_EDGE);
//	        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_WRAP_T, GL10.GL_CLAMP_TO_EDGE);
	        gl.glBindTexture(GL10.GL_TEXTURE_2D, k2);
	        gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, bufferUtil(textureCoor));
	        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, bufferUtil(t2));//设置四边形顶点数据(每3个构建一次,顶点数据类型,从第几个点开始,顶点数组数据)
	        gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3);
//	        // 左移 1.5 单位，并移入屏幕 6.0  
//	        gl.glTranslatef(1.5f, 0.0f, -6.0f); 
//	        //设置和绘制正方形  
//	        gl.glVertexPointer(3, GL10.GL_FIXED, 0, bufferUtil(quaterBuffer)); 
//	        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);
	 
	        // 取消纹理坐标设置  
	        gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
	        // 取消顶点设置  
	        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY); 
	    } 
	 
	    @Override 
	    public void onSurfaceChanged(GL10 gl, int width, int height) 
	    { 
	        float ratio = (float) width / height; 
	        //设置OpenGL场景的大小  
	        gl.glViewport(0, 0, width, height); 
	        //设置投影矩阵  
	        gl.glMatrixMode(GL10.GL_PROJECTION);
	        //重置投影矩阵  
	        gl.glLoadIdentity();
	        // 设置视口的大小  
//	        gl.glFrustumf(-ratio, ratio, -1, 1, 1, 20); 
//	        gl.glFrustumf(-ratio, ratio, -1, 1, 0.3f, 100);
	        GLU.gluPerspective(gl, 75.0f, ratio, 1, 100);
	        // 选择模型观察矩阵  
	        gl.glMatrixMode(GL10.GL_MODELVIEW);  
	        // 重置模型观察矩阵  
	        gl.glLoadIdentity();                             
	 
	    } 
	    
	    
	    private final int bind(GL10 gl, Bitmap bitmap) {
			gl.glEnable(GL10.GL_BLEND);
			gl.glEnable(GL10.GL_TEXTURE_2D);
			int[] textures = new int[1];
			gl.glGenTextures(1, textures, 0);
			gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);
			gl.glTexParameterf(
					GL10.GL_TEXTURE_2D, 
					GL10.GL_TEXTURE_MIN_FILTER,
	                GL10.GL_NEAREST);
	        gl.glTexParameterf(
	        		GL10.GL_TEXTURE_2D,
	                GL10.GL_TEXTURE_MAG_FILTER,
	                GL10.GL_LINEAR);
	        gl.glTexParameterf(
	        		GL10.GL_TEXTURE_2D, 
	        		GL10.GL_TEXTURE_WRAP_S,
	                GL10.GL_CLAMP_TO_EDGE);
	        gl.glTexParameterf(
	        		GL10.GL_TEXTURE_2D, 
	        		GL10.GL_TEXTURE_WRAP_T,
	                GL10.GL_CLAMP_TO_EDGE);
	        gl.glTexEnvf(
	        		GL10.GL_TEXTURE_ENV, 
	        		GL10.GL_TEXTURE_ENV_MODE,
	                GL10.GL_REPLACE);
		    GLUtils.texImage2D(
		        		GL10.GL_TEXTURE_2D, 0, 
		        		bitmap, 0);
		    gl.glDisable(GL10.GL_BLEND);
		    gl.glDisable(GL10.GL_TEXTURE_2D);
		    bitmap.recycle();
			return textures[0];
		}
	    int k, k2;
	    ByteOrder b;
	    @Override 
	    public void onSurfaceCreated(GL10 gl, EGLConfig config) 
	    { 
	        // 启用阴影平滑  
	        gl.glShadeModel(GL10.GL_SMOOTH); 
	         
	        // 黑色背景  
	        gl.glClearColor(0, 0, 0, 0); 
	         
	        // 设置深度缓存  
	        gl.glClearDepthf(1.0f);                          
	        // 启用深度测试  
	        gl.glEnable(GL10.GL_DEPTH_TEST);                         
	        // 所作深度测试的类型  
	        gl.glDepthFunc(GL10.GL_LEQUAL);                          
	         
	        // 告诉系统对透视进行修正  
	        gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST);
	        /*选中纹理选项,对该项进行设置*/
//	        gl.glEnable(GL10.GL_TEXTURE_2D);//启用2d纹理映射
//	        gl.glGenTextures(1, textures, 0);//构建纹理缓存数组,构建1,放入textures数组的第0个元素
//	        gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);//选中绑定2D纹理到textures0指定的缓存区
//	        GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap, 0);//将bimap作为纹理载入指定的缓存区,指定要使用的纹理并在渲染多边形时映射
	        /*设置纹理参数:纹理使用线性过滤*/
//	        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);
//	        gl.glTexParameterx(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_NEAREST);
	        /*设置纹理坐标数组*/
//	        gl.glEnable(GL10.GL_TEXTURE_2D);
	        
	        k = bind(gl, bt[2]);
	        k2 = bind(gl, bt[0]);
	    }
	    private void drawText(GL10 gl) {
			// TODO Auto-generated method stub
	    	String str = "current fps = ";  
	    	int n = str.length();  
	    	//设置要在屏幕上显示字符的起始位置  
	    	//逐个显示字符串中的每个字符  
		}
	    private Bitmap bitmap = BitmapFactory.decodeStream(ResourePath.getSourceInputStream("resource/images/test_pattern.png"));
	    private Bitmap[] bt = new Bitmap[]{
	    		BitmapFactory.decodeStream(ResourePath.getSourceInputStream("resource/images/test_pattern.png")),
	    		BitmapFactory.decodeStream(ResourePath.getSourceInputStream("resource/images/test.png")),
	    		BitmapFactory.decodeStream(ResourePath.getSourceInputStream("resource/images/wall1.png"))
	    };
	    private int[] textures = new int[1];
	    /**纹理坐标数组*/
	    private float[] textureCoor = new float[]{
	    		0.0f, 0.0f,
	    		1.0f, 1.0f,
	    		0.0f, 1.0f,
	    };
	    /* 
	     * OpenGL 是一个非常底层的画图接口，它所使用的缓冲区存储结构是和我们的 java 程序中不相同的。 
	     * Java 是大端字节序(BigEdian)，而 OpenGL 所需要的数据是小端字节序(LittleEdian)。 
	     * 所以，我们在将 Java 的缓冲区转化为 OpenGL 可用的缓冲区时需要作一些工作。建立buff的方法如下 
	     * */  
	    public Buffer bufferUtil(float []arr){  
	         FloatBuffer mBuffer;
	         //先初始化buffer,数组的长度*4,因为一个int占4个字节  
	         ByteBuffer qbb = ByteBuffer.allocateDirect(arr.length * 4);  
	         //数组排列用nativeOrder  
	         qbb.order(ByteOrder.nativeOrder());  
	          
	         mBuffer = qbb.asFloatBuffer();  
	         mBuffer.put(arr);  
	         mBuffer.position(0);  
	           
	         return mBuffer;  
	    }
	} 

//	public class GLRender implements GLSurfaceView.Renderer{

//	    //控制旋转的角度
//	    private float rotate;
//
//	    @Override
//	    public void onSurfaceCreated(GL10 gl,
//	     EGLConfig config) {
//	        //关闭抗抖动
//	        gl.glDisable(GL10.GL_DITHER);
//	        //设置系统对透视进行修正
//	        gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST);
//	        gl.glClearColor(0, 0, 0, 0);
//	        //设置阴影平滑模式
//	        gl.glShadeModel(GL10.GL_SMOOTH);
//	        //启动深度测试
//	        gl.glEnable(GL10.GL_DEPTH_TEST);
//	        //设置深度测试的类型
//	        gl.glDepthFunc(GL10.GL_LEQUAL);
//
//	    }
//
//	    @Override
//	    public void onSurfaceChanged(GL10 gl, int width, int height) {
//	        //设置3D视窗的大小及位置
//	        gl.glViewport(0, 0, width, height);
//	        //将当前矩阵模式设为投影矩形
//	        gl.glMatrixMode(GL10.GL_PROJECTION);
//	        //初始化单位矩阵
//	        gl.glLoadIdentity();
//	        //计算透视窗口的宽度高度比
//	        float ratio = (float) width / height;
//	        //调用此方法设置透视窗口的空间大小
//	        gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);
//	    }
//
//	    @Override
//	    public void onDrawFrame(GL10 gl) {
//	        //清除屏幕缓存和深度缓存
//	        gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
//	        //启用顶点坐标数据
//	        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
//	        //启用顶点颜色数据
//	        gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
//	        //设置当前矩阵堆栈为模型堆栈
//	        gl.glMatrixMode(GL10.GL_MODELVIEW);
//	        //------绘制第一个图形-----
//	        //重置当前的模型视图矩阵
//	        gl.glLoadIdentity();
//	        gl.glTranslatef(0.95f, -0.8f, -1.5f); //1️⃣
//	        //设置顶点位置数据
//	        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, PointData.floatBufferUtil(PointData.triangleData));
//	        //设置顶点颜色数据
//	        gl.glColorPointer(4, GL10.GL_FIXED, 0, PointData.intBufferUtil(PointData.triangleColor));
//	        //根据顶点数据绘制平面图形
//	        gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3);
//
////	        //-----绘制第二个图形-----
////	        //重置当前的模型视图矩阵
////	        gl.glLoadIdentity();
////	        gl.glTranslatef(0.95f, 0.8f, -1.5f);
////	        //设置顶点位置数据
////	        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, PointData.floatBufferUtil(PointData.rectData));
////	        //设置顶点颜色数据
////	        gl.glColorPointer(4, GL10.GL_FIXED, 0, PointData.intBufferUtil(PointData.rectColor));
////	        //更具顶点数据绘制平面图形
////	        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);
//
////	        //-----绘制第三个图形----
////	        //重置当前的模型视图矩阵
////	        gl.glLoadIdentity();
////	        gl.glTranslatef(-0.95f, 0.8f, -1.5f);
////	        //设置顶点位置数据
////	        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, PointData.floatBufferUtil(PointData.rectData2));
////	        //根据顶点数据绘制平面图形
////	        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);
//
////	        //-----绘制第四个图形-----
////	        //重置当前的模型视图矩阵
////	        gl.glLoadIdentity();
////	        gl.glTranslatef(-0.95f, -0.8f, -1.5f);
////	        //设置使用纯色填充 **需要注意: 使用纯色填充需要禁用顶点颜色数组
////	        gl.glColor4f(1.0f, 0.2f, 0.2f, 0.0f);
////	        gl.glDisableClientState(GL10.GL_COLOR_ARRAY);
////	        //设置顶点位置数据
////	        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, PointData.floatBufferUtil(PointData.pentacle));
////	        //根据顶点数据绘制图形
////	        gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 5);
//
////	        //----绘制第五个图形---
////	        //重置当前的模型视图矩阵
////	        gl.glLoadIdentity();
////	        gl.glTranslatef(0f, 0f, -1.5f);
////	        gl.glRotatef(rotate, 0f, 0.2f, 0f);
////	        //设置顶点位置数据
////	        gl.glVertexPointer(3, GL10.GL_FLOAT, 0, PointData.floatBufferUtil(TDPointData.taperVertices));
////	        //启用顶点颜色组
////	        gl.glEnableClientState(GL10.GL_COLOR_ARRAY);
////	        //设置顶点颜色数据
////	        gl.glColorPointer(4, GL10.GL_FIXED, 0, PointData.intBufferUtil(TDPointData.taperColors));
////	        //按taperFacetsBuffer指定的面绘制三角形
////	        ByteBuffer byteBuffer = PointData.byteBufferUtil(TDPointData.taperFacets);
////	        gl.glDrawElements(GL10.GL_TRIANGLE_STRIP, byteBuffer.remaining(), GL10.GL_UNSIGNED_BYTE, byteBuffer);
//
//
//	        //绘制结束
//	        gl.glFinish();
//	        gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
//	        //旋转角度+1
//	        rotate += 1;
//	    }
}
